介绍了几种交换排序的算法
1。冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
Code:
using System;
usingSystem.Collections.Generic;
namespaceCom.Colobu.Algorithm.Exchange
{
///<summary>
///冒泡排序是这样实现的：
///
/// 1.首先将所有待排序的数字放入工作列表中。
/// 2.从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。
/// 3.重复2号步骤(倒数的数字加1。例如：第一次到倒数第二个数字，第二次到倒数第三个数字，依此类推...)，直至再也不能交换。
///
///平均时间复杂度:O(n^2)
///Stability:Yes
///</summary>
public classBubbleSortAlgorithm
{
public static voidBubbleSort<T>(IList<T>szArray) whereT:IComparable
{
int i;
int j;
T temp; //交换变量
bool swapped = false;
for (i = szArray.Count - 1; i >= 0;i--)
{
for (j = 1; j <= i;j++)
{
if (szArray[j - 1].CompareTo(szArray[j]) >0)
{
temp = szArray[j - 1];
szArray[j - 1] =szArray[j];
szArray[j] = temp;
swapped = true;
}
}
if (!swapped)
break;
}
}
}
}
using System;
using System.Collections.Generic;
namespace Com.Colobu.Algorithm.Exchange
{
///<summary>
///冒泡排序是这样实现的：
///
/// 1.首先将所有待排序的数字放入工作列表中。
/// 2.从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。
/// 3.重复2号步骤(倒数的数字加1。例如：第一次到倒数第二个数字，第二次到倒数第三个数字，依此类推...)，直至再也不能交换。
///
///平均时间复杂度:O(n^2)
///Stability:Yes
///</summary>
public classBubbleSortAlgorithm
{
public static voidBubbleSort<T>(IList<T>szArray) where T:IComparable
{
int i;
int j;
T temp; //交换变量
bool swapped = false;
for (i = szArray.Count - 1; i >= 0; i--)
{
for (j = 1; j <= i; j++)
{
if (szArray[j - 1].CompareTo(szArray[j]) > 0)
{
temp = szArray[j - 1];
szArray[j - 1] = szArray[j];
szArray[j] = temp;
swapped = true;
}
}
if (!swapped)
break;
}
}
}
}
2。快速排序
using System;
usingSystem.Collections.Generic;
namespaceCom.Colobu.Algorithm.Exchange
{
///<summary>
///<b>快速排序</b>是所有排序算法中最高效的一种.
///它采用了分治的思想：先保证列表的前半部分都小于后半部分，
///然后分别对前半部分和后半部分排序，这样整个列表就有序了。
///这是一种先进的思想，也是它高效的原因。
///因为在排序算法中，算法的高效与否与列表中数字间的比较次数有直接的关系，
///而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后
///都不再跟后半部分的数进行比较了，大大减少了数字间不必要的比较。
///
///平均时间复杂度:O(nlogn)
///Stability:No
///</summary>
public classQuickSortAlgorithm
{
// QuickSortimplementation
public static voidQuickSort<T>(IList<T>szArray, int nLower, int nUpper) where T :IComparable
{
if (nLower <nUpper)
{
int nSplit = Partition(szArray, nLower,nUpper);
QuickSort(szArray, nLower, nSplit -1);
QuickSort(szArray, nSplit + 1,nUpper);
}
}
// QuickSort partitionimplementation
private static intPartition<T>(IList<T>szArray, int nLower, int nUpper) whereT:IComparable
{
T szPivot = szArray[nLower];//分隔点的值，用数字第一个值代替
int nLeft = nLower +1;//左边开始点
int nRight = nUpper;//右边开始点
T szSwap; //交换变量
//开始查找
//将小于分隔点的值都挪到左边
//将小于分隔点的值都挪到右边
while (nLeft <=nRight)
{
//找到左边第一个大于分隔点的值
while (nLeft <= nRight&&szArray[nLeft].CompareTo(szPivot) <=0)
nLeft = nLeft + 1;
//找到右边第一个小于分隔点的值
while (nLeft <= nRight&&szArray[nRight].CompareTo(szPivot) >0)
nRight = nRight - 1;
//如果左右还没有交叉(碰头)，交换左右两个值
if (nLeft <nRight)
{
szSwap = szArray[nLeft];
szArray[nLeft] =szArray[nRight];
szArray[nRight] = szSwap;
nLeft = nLeft + 1;
nRight = nRight - 1;
}
}
//将分隔点移动到最后那个点,此时nRight = nLeft -1
//所以那个点的值小于分隔点，可以与分隔点进行交换
szSwap = szArray[nLower];
szArray[nLower] =szArray[nRight];
szArray[nRight] = szSwap;
//现在在nRight左边的值都小于分隔点，nRight右边的值都大于分隔点
return nRight;
}
}
}
3。奇偶排序
using System;
usingSystem.Collections.Generic;
namespaceCom.Colobu.Algorithm.Exchange
{
///<summary>
///<b>奇偶排序</b>的思路是在数组中重复两趟扫描。
///第一趟扫描选择所有的数据项对，a[j]和a[j+1]，j是奇数(j=1, 3,5……)。
///如果它们的关键字的值次序颠倒，就交换它们。
///第二趟扫描对所有的偶数数据项进行同样的操作(j=2,4,6……)。
///重复进行这样两趟的排序直到数组全部有序。
///
///平均时间复杂度:O(n^2)
///Stability:Yes
///</summary>
public classOddEvenSortAlgorithm
{
public static voidOddEvenSort<T>(IList<T>szArray) where T :IComparable
{
bool sorted = false;
while (!sorted)
{
sorted = true;
// odd-even
for (int i = 1; i < szArray.Count - 1; i +=2)
{
if (szArray[i].CompareTo(szArray[i + 1]) >0)
{
Swap(szArray, i, i + 1);
sorted = false;
}
}
// even-odd
for (int j = 0; j < szArray.Count - 1; j +=2)
{
if (szArray[j].CompareTo(szArray[j + 1]) >0)
{
Swap(szArray, j, j + 1);
sorted = false;
}
}
}
}
private static voidSwap<T>(IList<T>szArray, int i, int j)
{
T tmp = szArray[i];
szArray[i] = szArray[j];
szArray[j] = tmp;
}
}
}
4。鸡尾酒排序，也就是定向冒泡排序 , 鸡尾酒搅拌排序 , 搅拌排序 (也可以视作选择排序的一种变形), 涟漪排序 , 来回排序 or 快乐小时排序 ,是冒泡排序的一种变形。此算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序
using System;
usingSystem.Collections.Generic;
namespaceCom.Colobu.Algorithm.Exchange
{
///<summary>
///<b>鸡尾酒排序</b>，也就是双向冒泡排序(bidirectionalbubble sort), 鸡尾酒搅拌排序,搅拌排序
///(也可以视作选择排序的一种变形), 涟漪排序, 来回排序 or快乐小时排序,
///是冒泡排序的一种变形。
///此算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序。
///
///平均时间复杂度:O(n^2)
///Stability:Yes
///</summary>
public classCocktailSortAlgorithm
{
public static voidCocktailSort<T>(IList<T>szArray) where T :IComparable
{
int bottom = 0;
int top = szArray.Count -1;
bool swapped = true;
while (swapped == true) // if no elements have been swapped, thenthe list is sorted
{
swapped = false;
for (int i = bottom; i < top; i = i +1)
{
if (szArray[i].CompareTo(szArray[i + 1]) >0) // test whether the two elements are in thecorrect order
{
Swap(szArray,i,i + 1); // let the two elements changeplaces
swapped = true;
}
}
// decreases top the because the element with the largest value inthe unsorted
// part of the list is now on the positiontop
top = top - 1;
for (int i = top; i > bottom; i = i -1)
{
if (szArray[i].CompareTo(szArray[i - 1]) <0)
{
Swap(szArray,i,i - 1);
swapped = true;
}
}
// increases bottom because the element with the smallest value intheunsorted
// part of the list is now on the positionbottom
bottom = bottom + 1;
}
}
private static voidSwap<T>(IList<T>szArray, int i,int j)
{
T tmp = szArray[i];
szArray[i] = szArray[j];
szArray[j] = tmp;
}
}
}
5。Gnome Sort is a sorting algorithm which issimilar to insertion sort, except that moving an element to itsproper place is accomplished by a series of swaps, as in bubblesort. The name comes from the supposed behavior of the Dutchgarden gnome in sorting a line of flowerpots and is described onDick Grune's Gnome sort page.
Code:
using System;
usingSystem.Collections.Generic;
namespaceCom.Colobu.Algorithm.Exchange
{
///<summary>
///<b>Gnomesort</b> is a sorting algorithm whichis similar to insertionsort,
/// exceptthat moving an element to its proper place isaccomplished
/// by aseries of swaps, as in bubblesort.
/// GnomeSort is based on the technique used by the standard Dutch GardenGnome.
/// Here ishow a garden gnome sorts a line of flowerpots.
///Basically, he looks at the flower pot next to him and the previousone;
/// if theyare in the right order he steps one potforward,
///otherwise he swaps them and steps one potbackwards.
/// Boundaryconditions: if there is no previouspot,
/// he stepsforwards; if there is no pot next to him, he isdone.
///
///平均时间复杂度:O(n^2)
///Stability:Yes
///</summary>
public classGnomeSortAlgorithm
{
public static voidGnomeSort<T>(IList<T>szArray) where T :IComparable
{
int i = 1;
int j =2;
int count =szArray.Count;
while (i <count)
{
if (szArray[i - 1].CompareTo(szArray[i]) < 0) //fordescending sort, reverse the comparison to>=
{
i = j;
j = j + 1;
}
else
{
Swap(szArray, i - 1, i);
i = i - 1;
if (i == 0)
{
i = j;
j = j + 1;
}
}
}
}
private static voidSwap<T>(IList<T>szArray, int i, int j)
{
T tmp = szArray[i];
szArray[i] = szArray[j];
szArray[j] = tmp;
}
}
}
6。Comb Sort
using System;
usingSystem.Collections.Generic;
namespaceCom.Colobu.Algorithm.Exchange
{
///<summary>
///<b>Combsort</b> improves on bubble sort, andrivals algorithms likeQuicksort.
/// Thebasic idea is to eliminate turtles, or small values near the end ofthelist,
/// since ina bubble sort these slow the sorting downtremendously.
///
///平均时间复杂度:O(nlogn)
///Stability:No
///</summary>
public classCombSortAlgorithm
{
public static voidCombSort<T>(IList<T>szArray) where T :IComparable
{
int gap = szArray.Count;
bool swapped = true;
while (gap > 1 ||swapped)
{
if (gap >1)
{
gap = (int)(gap / 1.25);
}
int i = 0;
swapped = false;
while (i + gap <szArray.Count)
{
if (szArray[i].CompareTo(szArray[i + gap]) >0)
{
T t = szArray[i];
szArray[i] = szArray[i +gap];
szArray[i + gap] = t;
swapped = true;
}
i++;
}
}
}
}
}
随机排序结果：下面是对一个随机序列的排序效率结果:
test1:
quicksorttime: 0.10864 ms （*）
bubblesorttime: 5.83652 ms
cocktailtime: 6.13016 ms
comb sorttime: 1.38076 ms
gnome sorttime: 4.38388 ms
odd-even sorttime: 6.846 ms (@)
test2:
quicksorttime: 0.1225ms （*）
bubblesorttime: 5.35685 ms
cocktailtime: 5.53548 ms
comb sorttime: 0.22765 ms
gnome sorttime: 4.10683 ms
odd-even sorttime: 6.7337ms (@)
test3:
quicksorttime: 0.11808 ms （*）
bubblesorttime: 5.49997 ms
cocktailtime: 5.32455 ms
comb sorttime: 0.20061 ms
gnome sorttime: 4.66813 ms
odd-even sorttime: 7.18163 ms
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
